/*
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

import sun.misc.SharedSecrets;

/**
 * Resizable-array implementation of the <tt>List</tt> interface.  Implements
 * all optional list operations, and permits all elements, including
 * <tt>null</tt>.  In addition to implementing the <tt>List</tt> interface,
 * this class provides methods to manipulate the size of the array that is
 * used internally to store the list.  (This class is roughly equivalent to
 * <tt>Vector</tt>, except that it is unsynchronized.)
 *
 * <p>The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>,
 * <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant
 * time.  The <tt>add</tt> operation runs in <i>amortized constant time</i>,
 * that is, adding n elements requires O(n) time.  All of the other operations
 * run in linear time (roughly speaking).  The constant factor is low compared
 * to that for the <tt>LinkedList</tt> implementation.
 *
 * <p>Each <tt>ArrayList</tt> instance has a <i>capacity</i>.  The capacity is
 * the size of the array used to store the elements in the list.  It is always
 * at least as large as the list size.  As elements are added to an ArrayList,
 * its capacity grows automatically.  The details of the growth policy are not
 * specified beyond the fact that adding an element has constant amortized
 * time cost.
 *
 * <p>An application can increase the capacity of an <tt>ArrayList</tt> instance
 * before adding a large number of elements using the <tt>ensureCapacity</tt>
 * operation.  This may reduce the amount of incremental reallocation.
 *
 * <p><strong>Note that this implementation is not synchronized.</strong>
 * If multiple threads access an <tt>ArrayList</tt> instance concurrently,
 * and at least one of the threads modifies the list structurally, it
 * <i>must</i> be synchronized externally.  (A structural modification is
 * any operation that adds or deletes one or more elements, or explicitly
 * resizes the backing array; merely setting the value of an element is not
 * a structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the list.
 * <p>
 * If no such object exists, the list should be "wrapped" using the
 * {@link Collections#synchronizedList Collections.synchronizedList}
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the list:<pre>
 *   List list = Collections.synchronizedList(new ArrayList(...));</pre>
 *
 * <p><a name="fail-fast">
 * The iterators returned by this class's {@link #iterator() iterator} and
 * {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:</a>
 * if the list is structurally modified at any time after the iterator is
 * created, in any way except through the iterator's own
 * {@link ListIterator#remove() remove} or
 * {@link ListIterator#add(Object) add} methods, the iterator will throw a
 * {@link ConcurrentModificationException}.  Thus, in the face of
 * concurrent modification, the iterator fails quickly and cleanly, rather
 * than risking arbitrary, non-deterministic behavior at an undetermined
 * time in the future.
 *
 * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
 * as it is, generally speaking, impossible to make any hard guarantees in the
 * presence of unsynchronized concurrent modification.  Fail-fast iterators
 * throw {@code ConcurrentModificationException} on a best-effort basis.
 * Therefore, it would be wrong to write a program that depended on this
 * exception for its correctness:  <i>the fail-fast behavior of iterators
 * should be used only to detect bugs.</i>
 *
 * <p>This class is a member of the
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @author Josh Bloch
 * @author Neal Gafter
 * @see Collection
 * @see List
 * @see LinkedList
 * @see Vector
 * @since 1.2
 */

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空对象数组 在创建集合时如果传入的初始为0 默认为该数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 空对象数组 在创建集合时如果没有传入初始容量,默认为为该数组
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 数据存储的数组，在插入之前判断，如果elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，数组的会扩容至默认容量
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * 数组的长度
     */
    private int size;

    /**
     * 指定初始容量的构造函数 数组的容量在指定时必须大于等于0否则会抛出IllegalArgumentException
     * 在已知集合元素大小的情况下 最好使用该构造函数创建集合 这样集合再添加的时候就不会进行 扩容操作
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            // 指定容量大于0的时候创建一个指定容量的数组用来存储集合中的数据
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            // 指定容量等于0是 赋值为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            // 指定容量小于0抛出异常
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        }
    }

    /**
     * 不指定初始容量 使用默认的空数组
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 指定初始元素为指定集合内元素的构造函数
     */
    public ArrayList(Collection<? extends E> c) {
        // 调用toArray方法 获得指定集合的数组元素 并指定给当前元结合的数组
        elementData = c.toArray();
        // 集合元素数赋值 并判断集合长度是不是为0
        if ((size = elementData.length) != 0) {
            // 判断类型返回是不是Object[]类型
            if (elementData.getClass() != Object[].class)
                // 拷贝数组 原数组为elementData 长度为size 数组类型为Object[].class
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 如果集合的长度为0 数组为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    /**
     * 将集合中数组的容量调整为当前集合的大小
     * 集合每次扩容之后会留存部分容量这个操作就是移除这部分
     */
    public void trimToSize() {
        // 修改次数增加
        modCount++;

        if (size < elementData.length) {
            // 如果集合长度比数组长度小
            // 三目运算
            elementData = (size == 0)
                    //如果集合长度为0 原数组直接为空数组
                    ? EMPTY_ELEMENTDATA
                    //  如果不是0 就直接拷贝数据到新数组中
                    : Arrays.copyOf(elementData, size);
        }
    }


    /**
     * 设置基础容量
     * 在数组已经初始化之后 设置数组的容量
     */
    public void ensureCapacity(int minCapacity) {
        // 确定数组的默认容量
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                // 如果不是默认数组 则数组最小长度为0 则扩容容量就是设置容量
                ? 0
                // 不是默认数组 就是使用默认容量
                : DEFAULT_CAPACITY;

        // 如果数组默认容量大于等于设置容量 就不进行扩容
        // 如果数组默认容量小于设置容量 就进行扩容
        if (minCapacity > minExpand) {
            // 扩容
            ensureExplicitCapacity(minCapacity);
        }
    }

    // 计算数组扩容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 如果数组为默认数组 扩容之容量就是默认容量和最小扩容容量的最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 返回数组扩容容量
        return minCapacity;
    }

    /**
     * 确认是否需要扩容
     *
     * @param minCapacity 最小容量
     */
    private void ensureCapacityInternal(int minCapacity) {
        //确保目前已有的数组足够存储数据
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    /**
     * 确保目前已有的数组足够存储数据
     *
     * @param minCapacity 计算得到的最小容量
     */
    private void ensureExplicitCapacity(int minCapacity) {
        // 修改次数增加
        modCount++;

        // 是否需要扩容
        if (minCapacity - elementData.length > 0)
            // 扩容
            grow(minCapacity);
    }

    /**
     * 要分配的数组的最大大小。
     * 一些vm在数组中保留一些头字。
     * 尝试分配更大的阵列可能会导致
     * OutOfMemoryError:请求的数组大小超过VM限制
     * 这一段话我原本翻译下来 之前还特意查过原因回头整理一下发出来
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 增加容量保证可以容纳最小要求的数组
     *
     * @param minCapacity 最小要求扩容大小
     */
    private void grow(int minCapacity) {
        // 获取数组本身的大小
        int oldCapacity = elementData.length;
        // 计算新的容量 扩充为原来的3/2 及扩大1/2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            // 如果计算新的容量小于最低容量 扩展大小为最低容量  防止计算的容量并不能满足需求
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 若果扩展大小超过设置的最大值 通过hugeCapacity计算真正数组的容量
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        // 对数组数据进行拷贝
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    // 数组容量很大时 进行荣来那个修改
    private static int hugeCapacity(int minCapacity) {
        // 容量小于0 直接oom
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        // 如果最小需求容量大于默认最大值 就去int 最大值 否则就去默认最大值
        // 如果创建这么打一个数组个人都感觉 oom
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

    /**
     * 获取集合中元素的数量
     */
    public int size() {
        return size;
    }

    /**
     * 判断数组是否为空数组
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 判断集合中是否包含某个元素
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 获得指定元素第一次出现的位置 若不存在返回-1
     * 这里不知道为什么不使用迭代器了
     * 个人猜测可能是因为迭代器会出现ConcurrentModificationException
     * 所以才使用了对数组元素比较
     */
    public int indexOf(Object o) {
        if (o == null) {
            // 如果对象是null
            for (int i = 0; i < size; i++)
                //比较数据是否为null
                if (elementData[i] == null)
                    return i;
        } else {
            // 如果对象不是null
            for (int i = 0; i < size; i++)
                // 使用equals进行比较 对象重写equals
                if (o.equals(elementData[i]))
                    return i;
        }
        // 未找到数据返回-1
        return -1;
    }

    /**
     * 获得指定元素最后一次一次出现的位置 若不存在返回-1
     * 倒序遍历数组
     */
    public int lastIndexOf(Object o) {
        if (o == null) {
            // 如果对象是null
            for (int i = size - 1; i >= 0; i--)
                //比较数据是否为null
                if (elementData[i] == null)
                    return i;
        } else {
            // 如果对象不是null
            for (int i = size - 1; i >= 0; i--)
                // 使用equals进行比较 对象重写equals
                if (o.equals(elementData[i]))
                    return i;
        }
        // 未找到数据返回-1
        return -1;
    }

    /**
     * 拷贝一个新的集合
     * 集合中元素本身不会被复制 即拷贝后如果对集合中的元素修改 会导致两个集合中的元素都改变
     */
    public Object clone() {
        try {
            // 创建一个对象
            ArrayList<?> v = (ArrayList<?>) super.clone();
            // 拷贝集合中的数据
            v.elementData = Arrays.copyOf(elementData, size);
            // 新集合修改次数设置为0
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

    /**
     * 返回集合中的数据
     */
    public Object[] toArray() {
        // 返回集合中的数组数据 新的数组
        return Arrays.copyOf(elementData, size);
    }

    /**
     * 按照指定的类型 返回包含集合数据的数组
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // 如果指定类型数组长度不足以容纳全部数据 按照指定类型数组创建新的数组并拷贝集合中的数据
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        // 拷贝集合中的数据到指定数组中
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            // 当指定类型数组长度大于集合长度以null 区分两个几何数组和原数据
            a[size] = null;
        return a;
    }

    // Positional Access Operations

    /**
     * 根据下标获取数据
     */
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * 根据集合下标获取数据
     */
    public E get(int index) {
        //下标检查
        rangeCheck(index);
        // 根据下标获取数据并返回
        return elementData(index);
    }

    /**
     * 修改指定位置的元素 并被修改的元素
     */
    public E set(int index, E element) {
        // 指定位置检查
        rangeCheck(index);
        // 获取被修改的元素
        E oldValue = elementData(index);
        // 替换指定位置的数据
        elementData[index] = element;
        return oldValue;
    }

    /**
     * 在集合尾部添加一个元素
     */
    public boolean add(E e) {
        // 最小容量检测 同时修改modCount
        ensureCapacityInternal(size + 1);
        // 数据添加
        elementData[size++] = e;
        return true;
    }

    /**
     * 在指定位置插入一个元素
     */
    public void add(int index, E element) {
        // 增加操作位置检查
        rangeCheckForAdd(index);
        // 最小容量检测 同时修改modCount
        ensureCapacityInternal(size + 1);
        // 拷贝数组 将数组从elementData index 位置 拷贝到 elementData index + 1 拷贝长度为 size-length
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        // 对index位置数据进行赋值
        elementData[index] = element;
        size++;
    }

    /**
     * 删除指定未知的元素返回删除的数据 删除之后 所有元素作揖
     */
    public E remove(int index) {
        // 指定位置检查
        rangeCheck(index);
        // 修改集合modCount
        modCount++;
        // 获取删除位置
        E oldValue = elementData(index);
        // 计算 删除之后移动元素数量
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 移动元素数量大于01 进行数组移动
            // 将数组从elementData index+1 位置 拷贝到 elementData index1 拷贝长度为 numMoved
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        // 之前末尾的数据设置为null
        elementData[--size] = null; // clear to let GC do its work
        return oldValue;
    }

    /**
     * 从集合中删除第一个出现的指定元素
     */
    public boolean remove(Object o) {
        if (o == null) {
            // 如果元素是null
            for (int index = 0; index < size; index++)
                // 循环查看元素是否等于null
                if (elementData[index] == null) {
                    // 快速删除
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                // 循环查看元素是否等于指定元素
                if (o.equals(elementData[index])) {
                    // 快速删除
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    /*
     * 私有删除方法 跳过便捷检查和返回值直接删除
     */
    private void fastRemove(int index) {
        // 修改集合modCount
        modCount++;
        // 计算 删除之后移动元素数量
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 移动元素数量大于01 进行数组移动
            // 将数组从elementData index+1 位置 拷贝到 elementData index1 拷贝长度为 numMoved
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        // 之前末尾的数据设置为null
        elementData[--size] = null; // clear to let GC do its work
    }

    /**
     * 删除此集合中的所有元素
     */
    public void clear() {
        // 修改集合modCount
        modCount++;

        // clear to let GC do its work
        // 将数组中所有元素都设为null
//        elementData=EMPTY_ELEMENTDATA
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        // 将集合长度设为0
        size = 0;
    }

    /**
     * 将指定集合中的所有元素追加到此集合
     * 实现中先获取指定集合数组 之后所有操作都是通过指定集合数组去完成 如果中间指定集合发生改变 指定集合数组并不会随之发生改变
     */
    public boolean addAll(Collection<? extends E> c) {
        // 调用toArray 获取指定集合数组
        Object[] a = c.toArray();
        // 获取数组需要增加长度
        int numNew = a.length;
        // 所需要容量检测 并记录修改
        ensureCapacityInternal(size + numNew);  // Increments modCount
        // 将制定集合数组的数据从 开始位置拷贝到elementData中 拷贝起始位置为 集合长度 拷贝长度为 数组需要增加长度
        System.arraycopy(a, 0, elementData, size, numNew);
        // 集合长度修改
        size += numNew;
        return numNew != 0;
    }

    /**
     * 将指定集合中的所有元素从指定位置开始插入集合，
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        // 检测添加位置是否合法
        rangeCheckForAdd(index);
        // 调用toArray 获取指定集合数组
        Object[] a = c.toArray();
        // 获取数组需要增加长度
        int numNew = a.length;
        // 所需要容量检测 并记录修改
        ensureCapacityInternal(size + numNew);  // Increments modCount
        // 计算集合中的元素需要移动数量
        int numMoved = size - index;
        if (numMoved > 0)
            // 数组中的元素移动空出位置给指定集合的元素
            System.arraycopy(elementData, index, elementData, index + numNew,
                    numMoved);
        // 将指定集合中的元素加入集合中
        System.arraycopy(a, 0, elementData, index, numNew);
        // 集合长度修改
        size += numNew;
        return numNew != 0;
    }

    /**
     * 删除从fromIndex到toIndex全部数据
     */
    protected void removeRange(int fromIndex, int toIndex) {
        // 修改次数增加
        modCount++;
        // 集合中元素移动数量
        int numMoved = size - toIndex;
        // 移东集合中元素
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                numMoved);

        // clear to let GC do its work
        // 计算新集合的长度
        int newSize = size - (toIndex - fromIndex);
        // 删除数据
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

    /**
     * 检查下表是否在范围内
     * 未检查为负数情况 因为如果下标为负数 在操作时 ArrayIndexOutOfBoundsException
     * 如果下标超出范围抛出 IndexOutOfBoundsException
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 为添加操作进行位置检查
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            // 位置超出当前集合范围 或者小于0抛出异常
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 绑定异常信息
     */
    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }

    /**
     * 从集合中删除指定集合中全部元素
     */
    public boolean removeAll(Collection<?> c) {
        // 验证指定集合不是null
        Objects.requireNonNull(c);
        // 批量删除
        return batchRemove(c, false);
    }

    /**
     * 保留制定集合中的存在的元素
     */
    public boolean retainAll(Collection<?> c) {
        // 验证指定集合不是null
        Objects.requireNonNull(c);
        // 批量删除
        return batchRemove(c, true);
    }

    // 批量删除
    private boolean batchRemove(Collection<?> c, boolean complement) {
        //
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            // 循环判断
            for (; r < size; r++)
                // 如果删除组包含集合数据和complement相同
                if (c.contains(elementData[r]) == complement)
                    // 数组中的数据赋值
                    elementData[w++] = elementData[r];
        } finally {
            if (r != size) {
                // 将未参与循环的数据拷贝下来
                System.arraycopy(elementData, r,
                        elementData, w,
                        size - r);
                // 重新设置数组长度
                w += size - r;
            }
            if (w != size) {
                // 如果数组长度和原数组长度不一样 将超出部分的数据删除
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                // 充值修改次数
                modCount += size - w;
                // 修改集合长度
                size = w;
                modified = true;
            }
        }
        return modified;
    }

    /**
     * 将集合中的数据写到流中 即序列化
     */
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        // 记录修改值
        int expectedModCount = modCount;
        // 默认序列化
        // static修饰和transient修饰不处理
        s.defaultWriteObject();

        // 记录数组的长度
        // 兼容jdk1.6
        // readObject 实现 int arrayLength = s.readInt();
        // Object[] a = elementData = new Object[arrayLength];
        s.writeInt(size);
        // 按照顺序写集合元素
        for (int i = 0; i < size; i++) {
            s.writeObject(elementData[i]);
        }
        // 修改检测
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    /**
     * 从流中创建数组对象 反序列化
     */
    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // 默认反序列化 获得modCount和size
        s.defaultReadObject();
        // 兼容
        // 在jdk1.6中为 int arrayLength = s.readInt();
        // Object[] a = elementData = new Object[arrayLength];
        s.readInt(); // ignored

        if (size > 0) {
            // 计算所需容量大小
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
            // 确保足够的容量
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // 将数据写入数组中
            for (int i = 0; i < size; i++) {
                a[i] = s.readObject();
            }
        }
    }

    /**
     * 返回从index开始的此集合中元素上的列表迭代器
     */
    public ListIterator<E> listIterator(int index) {
        // 判断列表迭代器位置
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: " + index);
        // 返回ListItr对象
        return new ListItr(index);
    }

    /**
     * 返回此集合中元素上的列表迭代器
     */
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    /**
     * 获得此集合的迭代器
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * 迭代器
     */
    private class Itr implements Iterator<E> {
        // 下一个元素的位置
        int cursor;
        // 上一个返回的元素
        int lastRet = -1;
        // 预期修改次数
        int expectedModCount = modCount;

        Itr() {
        }

        // 是否有下一个元素
        public boolean hasNext() {
            return cursor != size;
        }

        // 获取下一个元素
        public E next() {
            // 修改检查
            checkForComodification();
            // 获取访问元素下标
            int i = cursor;
            // 判断越界
            if (i >= size)
                throw new NoSuchElementException();
            // 获取数据
            Object[] elementData = ArrayList.this.elementData;
            // 判断越界
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            // 下一个元素x下表
            cursor = i + 1;
            // 修改lastRet = i
            // 获取值
            return (E) elementData[lastRet = i];
        }

        // 删除上一次调用next返回的数据
        public void remove() {
            // 判断上一次返回下表
            if (lastRet < 0)
                throw new IllegalStateException();
            // 修改检查
            checkForComodification();

            try {
                //删除上次访问元素
                ArrayList.this.remove(lastRet);
                // 下一次访问退一步
                cursor = lastRet;
                // 修改上一次返回为-1
                lastRet = -1;
                // 修改期望修改值
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        // 循环调用迭代器执行某个操作
        @Override
        public void forEachRemaining(Consumer<? super E> consumer) {
            // 操作不能是null
            Objects.requireNonNull(consumer);
            // 获取长度
            final int size = ArrayList.this.size;
            // 获取访问元素下标
            int i = cursor;
            // 判断越界
            if (i >= size) {
                return;
            }
            // 获取元素数组
            final Object[] elementData = ArrayList.this.elementData;
            // 修改检查
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            // 循环进行操作
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            // 修改下一个访问元素
            cursor = i;
            // 修改上一次返回为-1
            lastRet = i - 1;
            // 修改检查
            checkForComodification();
        }

        // 修改检查
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    /**
     * 列表迭代器
     */
    private class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;
        }

        // 是否又上一个元素
        public boolean hasPrevious() {
            return cursor != 0;
        }

        // 下一个元素下标
        public int nextIndex() {
            return cursor;
        }

        //上一个元素下标
        public int previousIndex() {
            return cursor - 1;
        }

        // 获取上一个元素
        public E previous() {
            // 异常检查
            checkForComodification();
            // 获取元素下标
            int i = cursor - 1;
            // 越界判断
            if (i < 0)
                throw new NoSuchElementException();
            // 获取数据
            Object[] elementData = ArrayList.this.elementData;
            // 修改判断
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            // 修改下一个元素位置
            cursor = i;
            // 修改lastRet = i
            // 获取值
            return (E) elementData[lastRet = i];
        }

        // 修改当前位置的元素
        public void set(E e) {
            // 如果调用过remove,add或者无法获取当前元素lastRet为-1
            if (lastRet < 0)
                throw new IllegalStateException();
            // 修改检查
            checkForComodification();

            try {
                // 修改数据
                ArrayList.this.set(lastRet, e);
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        // 添加元素
        public void add(E e) {
            checkForComodification();

            try {
                // 获取前访问位置
                int i = cursor;
                // 添加元素
                ArrayList.this.add(i, e);
                // 下一个访问位置增加
                cursor = i + 1;
                // 上一个访问元素为-1
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }

    /**
     * 返回此集合中从fromIndex（包含）到toIndex（不包含）之间的部分的子集合
     */
    public List<E> subList(int fromIndex, int toIndex) {
        // 分割元素位置检查
        subListRangeCheck(fromIndex, toIndex, size);
        // 元素分割
        return new SubList(this, 0, fromIndex, toIndex);
    }

    // 分割元素位置检查
    static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                    ") > toIndex(" + toIndex + ")");
    }

    // 元素分割自己
    private class SubList extends AbstractList<E> implements RandomAccess {
        // 源数据
        private final AbstractList<E> parent;
        // 父级偏移量
        private final int parentOffset;
        // 偏移量
        private final int offset;
        // 子集合长度
        int size;

        SubList(AbstractList<E> parent,
                int offset, int fromIndex, int toIndex) {
            this.parent = parent;
            this.parentOffset = fromIndex;
            // 自己偏移量 等于父级偏移量 加上自己的偏移量
            this.offset = offset + fromIndex;
            // 子集合长度 等于子集合开始位置减去开始位置
            this.size = toIndex - fromIndex;
            // 修改次数
            this.modCount = ArrayList.this.modCount;
        }

        // 修改指定位置的数据
        public E set(int index, E e) {
            // 位置检查
            rangeCheck(index);
            // 检查修改
            checkForComodification();
            // 获取原始数据
            E oldValue = ArrayList.this.elementData(offset + index);
            // 修改数据
            ArrayList.this.elementData[offset + index] = e;
            return oldValue;
        }

        // 获取指定位置的数据
        public E get(int index) {
            // 位置检查
            rangeCheck(index);
            // 检查修改
            checkForComodification();
            // 获取数据
            return ArrayList.this.elementData(offset + index);
        }

        // 获取长度
        public int size() {
            // 检查修改
            checkForComodification();
            return this.size;
        }

        // 在指定位置增加元素
        public void add(int index, E e) {
            // 新增范围检查
            rangeCheckForAdd(index);
            // 检查修改
            checkForComodification();
            // 增加数据
            parent.add(parentOffset + index, e);
            // 修改修改值
            this.modCount = parent.modCount;
            // 长度增加
            this.size++;
        }

        // 删除指定位置的元素
        public E remove(int index) {
            // 范围检查
            rangeCheck(index);
            // 修改查询
            checkForComodification();
            // 删除
            E result = parent.remove(parentOffset + index);
            // 修改修改值
            this.modCount = parent.modCount;
            // 长度减少
            this.size--;
            return result;
        }

        // 范围删除数据
        protected void removeRange(int fromIndex, int toIndex) {
            // 修改查询
            checkForComodification();
            // 删除元素
            parent.removeRange(parentOffset + fromIndex,
                    parentOffset + toIndex);
            // 修改修改值
            this.modCount = parent.modCount;
            // 长度减少
            this.size -= toIndex - fromIndex;
        }

        // 将指定集合中的元素加入该集合中
        public boolean addAll(Collection<? extends E> c) {
            return addAll(this.size, c);
        }

        // 将指定集合中的元素从指定位置开始加入该集合中
        public boolean addAll(int index, Collection<? extends E> c) {
            // 新增范围检查
            rangeCheckForAdd(index);
            // 获取长度
            int cSize = c.size();
            if (cSize == 0)
                return false;
            // 修改查询
            checkForComodification();
            // 添加数据
            parent.addAll(parentOffset + index, c);
            // 修改修改值
            this.modCount = parent.modCount;
            // 修改集合长度
            this.size += cSize;
            return true;
        }

        // 获取迭代器
        public Iterator<E> iterator() {
            // 调用列表迭代器
            return listIterator();
        }

        // 获取列表迭代器
        public ListIterator<E> listIterator(final int index) {
            // 修改查询
            checkForComodification();
            // 增加检查
            rangeCheckForAdd(index);
            // 偏移量
            final int offset = this.offset;

            return new ListIterator<E>() {
                // 调用next是下表
                int cursor = index;
                // 上一个返回的元素
                int lastRet = -1;
                // 期望修改值
                int expectedModCount = ArrayList.this.modCount;

                public boolean hasNext() {
                    return cursor != SubList.this.size;
                }

                // 获取下一个元素
                public E next() {
                    // 修改检查
                    checkForComodification();
                    // 获取元素下标
                    int i = cursor;
                    // 判断范围
                    if (i >= SubList.this.size)
                        throw new NoSuchElementException();
                    // 获取数组
                    Object[] elementData = ArrayList.this.elementData;
                    // 判断范围
                    if (offset + i >= elementData.length)
                        throw new ConcurrentModificationException();
                    // 下一个元素下标
                    cursor = i + 1;
                    // 上一次返回赋值
                    // 获取数据 获取小标为offset+lastRet
                    return (E) elementData[offset + (lastRet = i)];
                }

                // 是否包含上一个数据
                public boolean hasPrevious() {
                    return cursor != 0;
                }

                // 获取上一个数据
                public E previous() {
                    // 修改检查
                    checkForComodification();
                    // 获取元素下标
                    int i = cursor - 1;
                    // 判断范围
                    if (i < 0)
                        throw new NoSuchElementException();
                    // 获取数组
                    Object[] elementData = ArrayList.this.elementData;
                    // 判断范围
                    if (offset + i >= elementData.length)
                        throw new ConcurrentModificationException();
                    // 下一个元素下标
                    cursor = i;
                    // 上一次返回赋值
                    // 获取数据 获取小标为offset+lastRet
                    return (E) elementData[offset + (lastRet = i)];
                }

                // 循环操作
                public void forEachRemaining(Consumer<? super E> consumer) {
                    // 操作不能为null
                    Objects.requireNonNull(consumer);
                    // 获取长度
                    final int size = SubList.this.size;
                    // 获取当前开始位置
                    int i = cursor;
                    // 判断范围
                    if (i >= size) {
                        return;
                    }
                    // 获取几何数据
                    final Object[] elementData = ArrayList.this.elementData;
                    // 检查修改
                    if (offset + i >= elementData.length) {
                        throw new ConcurrentModificationException();
                    }
                    // 循环执行操作
                    while (i != size && modCount == expectedModCount) {
                        consumer.accept((E) elementData[offset + (i++)]);
                    }
                    // 修改最新返回数据下标 和next访问数据
                    lastRet = cursor = i;
                    // 检测修改
                    checkForComodification();
                }

                // 下一个元素的下标
                public int nextIndex() {
                    return cursor;
                }

                // 上一个元素的下标
                public int previousIndex() {
                    return cursor - 1;
                }

                // 删除当前返回的数据
                public void remove() {
                    // 如果调用过remove,add或者无法获取当前元素lastRet为-1
                    if (lastRet < 0)
                        throw new IllegalStateException();
                    // 检测修改
                    checkForComodification();

                    try {
                        // 删除最近访问数据
                        SubList.this.remove(lastRet);
                        // 下一次访问退一步
                        cursor = lastRet;
                        // 上次返回数据下标设为-1
                        lastRet = -1;
                        // 修改期望修改值
                        expectedModCount = ArrayList.this.modCount;
                    } catch (IndexOutOfBoundsException ex) {
                        throw new ConcurrentModificationException();
                    }
                }

                // 设置数据
                public void set(E e) {
                    // 如果调用过remove,add或者无法获取当前元素lastRet为-1
                    if (lastRet < 0)
                        throw new IllegalStateException();
                    // 检测修改
                    checkForComodification();

                    try {
                        // 修改数据
                        ArrayList.this.set(offset + lastRet, e);
                    } catch (IndexOutOfBoundsException ex) {
                        throw new ConcurrentModificationException();
                    }
                }

                // 添加数据
                public void add(E e) {
                    // 检测修改
                    checkForComodification();

                    try {
                        // 获取下一个值
                        int i = cursor;
                        // 添加一个数据
                        SubList.this.add(i, e);
                        // 跳过新添加的数据
                        cursor = i + 1;
                        // 最近返回设置-1
                        lastRet = -1;
                        // 修改期望值
                        expectedModCount = ArrayList.this.modCount;
                    } catch (IndexOutOfBoundsException ex) {
                        throw new ConcurrentModificationException();
                    }
                }

                // 检测修改
                final void checkForComodification() {
                    if (expectedModCount != ArrayList.this.modCount)
                        throw new ConcurrentModificationException();
                }
            };
        }

        // 返回此集合中从fromIndex（包含）到toIndex（不包含）之间的部分的子集合
        public List<E> subList(int fromIndex, int toIndex) {
            // 范围检查
            subListRangeCheck(fromIndex, toIndex, size);
            // 截取子集合
            return new SubList(this, offset, fromIndex, toIndex);
        }

        // 位置检查
        private void rangeCheck(int index) {
            if (index < 0 || index >= this.size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }

        //新增范围检查
        private void rangeCheckForAdd(int index) {
            if (index < 0 || index > this.size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }

        // 绑定异常信息
        private String outOfBoundsMsg(int index) {
            return "Index: " + index + ", Size: " + this.size;
        }

        // 检测修改
        private void checkForComodification() {
            if (ArrayList.this.modCount != this.modCount)
                throw new ConcurrentModificationException();
        }

        // 获取分割迭代器
        public Spliterator<E> spliterator() {
            // 检测修改
            checkForComodification();
            // 返回分割迭代器
            return new ArrayListSpliterator<E>(ArrayList.this, offset,
                    offset + this.size, this.modCount);
        }
    }

    // 循环执行某个动作
    @Override
    public void forEach(Consumer<? super E> action) {
        // 进行的操作不能为null
        Objects.requireNonNull(action);
        // 获取期望值
        final int expectedModCount = modCount;
        // 获取几何数据
        @SuppressWarnings("unchecked") final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        // 循环执行动作
        for (int i = 0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        // 修改检测
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    /**
     * 创建分割迭代器
     */
    @Override
    public Spliterator<E> spliterator() {
        return new ArrayListSpliterator<>(this, 0, -1, 0);
    }

    /**
     * 二分分割器迭代器
     */
    static final class ArrayListSpliterator<E> implements Spliterator<E> {

        // ArrayList对象
        private final ArrayList<E> list;
        // 当前元素下标（包含）调用advance和split会修改
        private int index;
        // 结束位置（不包含），-1表示到最后一个元素
        private int fence;
        // 用于存放list的modCount即修改值
        private int expectedModCount;

        // 构造器
        ArrayListSpliterator(ArrayList<E> list, int origin, int fence,
                             int expectedModCount) {
            this.list = list;
            this.index = origin;
            this.fence = fence;
            this.expectedModCount = expectedModCount;
        }

        // 获取fence值
        // 代码有点难懂 我就拆解了一下
        private int getFence() {
            int hi;
            ArrayList<E> lst;
            // hi= fence
            // hi < 0
            // 如果fence<0 且lst==null 就返回0
            // 如果fence<0  且lst!=null 重置expectedModCount  fence=lst.size 返回fence
            if ((hi = fence) < 0) {
                // lst = list
                // lst == null
                if ((lst = list) == null)
                    // fence=0
                    // hi=fence
                    hi = fence = 0;
                else {
                    expectedModCount = lst.modCount;
                    //fence = list.szie
                    // hi = fence
                    hi = fence = lst.size;
                }
            }
            return hi;
        }

        // 分割集合
        public ArrayListSpliterator<E> trySplit() {
            // hi是技术位置 lo时开始位置 mid是中间位置
            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
            // 三目运算 如果开始位置等于中间位置 就返回为null 否则返回从中间位置到结束位置的分割迭代器
            return (lo >= mid) ? null : // divide range in half unless too small
                    new ArrayListSpliterator<E>(list, lo, index = mid,
                            expectedModCount);
        }


        // 对下一个元素进行操作
        public boolean tryAdvance(Consumer<? super E> action) {
            // 操作不能为null
            if (action == null)
                throw new NullPointerException();
            // 获取结束位置和开始位置
            int hi = getFence(), i = index;
            if (i < hi) {
                // 开始位置+1
                index = i + 1;
                // 获取元素
                @SuppressWarnings("unchecked") E e = (E) list.elementData[i];
                // 执行动作
                action.accept(e);
                // 异常检查
                if (list.modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                return true;
            }
            return false;
        }

        // 循环执行操作
        public void forEachRemaining(Consumer<? super E> action) {
            // i 开始位置
            // hi 结束位置
            // mc 修改次数
            int i, hi, mc;
            // 集合
            ArrayList<E> lst;
            // 集合数组
            Object[] a;
            // 执行动作判空
            if (action == null)
                throw new NullPointerException();
            if ((lst = list) != null && (a = lst.elementData) != null) {
                // 集合不为null且集合数组不为null
                if ((hi = fence) < 0) {
                    // 结束为止小于0 修改次数等于集合修改次数 结束为止等于集合长度
                    mc = lst.modCount;
                    hi = lst.size;
                } else
                    // 否则修改次数等于期望修改值
                    mc = expectedModCount;
                // 开始位置大于0且小于集合数组长度
                if ((i = index) >= 0 && (index = hi) <= a.length) {
                    // 循环回去元素进行操作
                    for (; i < hi; ++i) {
                        @SuppressWarnings("unchecked") E e = (E) a[i];
                        action.accept(e);
                    }
                    // 修改判断
                    if (lst.modCount == mc)
                        return;
                }
            }
            throw new ConcurrentModificationException();
        }
        // 估计剩余元素
        public long estimateSize() {
            return (long) (getFence() - index);
        }

        //返回当前对象有哪些特征值
        // ORDERED 元素之间是有顺序的
        // SIZED 表示长度为有限个
        // SUBSIZED 迭代器所分割得到的子迭代器也是有序的
        public int characteristics() {
            return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
        }
    }

    // 如果条件成立删除
    @Override
    public boolean removeIf(Predicate<? super E> filter) {
        // 条件不能为空
        Objects.requireNonNull(filter);
        // 移除数量
        int removeCount = 0;
        // 使用BitSet对象记录要移除元素的下标
        final BitSet removeSet = new BitSet(size);
        final int expectedModCount = modCount;
        final int size = this.size;
        // 判断移除的元素 下表加入removeSet中
        for (int i = 0; modCount == expectedModCount && i < size; i++) {
            @SuppressWarnings("unchecked") final E element = (E) elementData[i];
            if (filter.test(element)) {
                removeSet.set(i);
                removeCount++;
            }
        }
        // 修改检测
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }

        // shift surviving elements left over the spaces left by removed elements
        // 是否有删除元素
        final boolean anyToRemove = removeCount > 0;
        if (anyToRemove) {
            // 数组新长度计算
            final int newSize = size - removeCount;
            // 数据移除
            for (int i = 0, j = 0; (i < size) && (j < newSize); i++, j++) {
                // 获取从i开始 返回位置为false的第一个索引
                i = removeSet.nextClearBit(i);
                elementData[j] = elementData[i];
            }
            // 超出元素设置为null
            for (int k = newSize; k < size; k++) {
                elementData[k] = null;  // Let gc do its work
            }
            // 设置集合长度
            this.size = newSize;
            // 检测修改
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            modCount++;
        }

        return anyToRemove;
    }

    @Override
    @SuppressWarnings("unchecked")
    // 替换元素操作
    public void replaceAll(UnaryOperator<E> operator) {
        // 操作不能为null
        Objects.requireNonNull(operator);
        // 修改值
        final int expectedModCount = modCount;
        // 集合长度
        final int size = this.size;
        // 循环进行数据操作 进行替换
        for (int i = 0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        // 修改检查
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

    @Override
    // 排序
    public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        // 对数组进行排序
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }


}
